package cn.shopping.core.daomanager.immutable.impl;

import cn.shopping.common.daomanager.impl.CommonDaoManagerImpl;
import cn.shopping.core.daomanager.immutable.ImmutableUploadInfoDaoManager;
import cn.shopping.core.dbo.UploadInfoDO;
import cn.shopping.core.mapper.UploadInfoMapper;
import org.springframework.beans.factory.annotation.Autowired;

import javax.annotation.PostConstruct;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


/**
 * 代码自动生成，请不要修改，切记！！！
 */
public class ImmutableUploadInfoDaoManagerImpl extends CommonDaoManagerImpl<UploadInfoDO,Long> implements ImmutableUploadInfoDaoManager {

        @Autowired
        private UploadInfoMapper uploadInfoMapper;




        @PostConstruct
        private void init(){
           super.setCommonMapper(uploadInfoMapper);

            Map<String,String> fieldMap=new HashMap<>();
            fieldMap.put(UploadInfoDO.ID,UploadInfoDO.DB_ID);
            fieldMap.put(UploadInfoDO.DB_ID,UploadInfoDO.DB_ID);

            fieldMap.put(UploadInfoDO.ORIGINAL_FILE_NAME,UploadInfoDO.DB_ORIGINAL_FILE_NAME);
            fieldMap.put(UploadInfoDO.DB_ORIGINAL_FILE_NAME,UploadInfoDO.DB_ORIGINAL_FILE_NAME);

            fieldMap.put(UploadInfoDO.FILE_NAME,UploadInfoDO.DB_FILE_NAME);
            fieldMap.put(UploadInfoDO.DB_FILE_NAME,UploadInfoDO.DB_FILE_NAME);

            fieldMap.put(UploadInfoDO.FILE_SUFFIX,UploadInfoDO.DB_FILE_SUFFIX);
            fieldMap.put(UploadInfoDO.DB_FILE_SUFFIX,UploadInfoDO.DB_FILE_SUFFIX);

            fieldMap.put(UploadInfoDO.FILE_PATH,UploadInfoDO.DB_FILE_PATH);
            fieldMap.put(UploadInfoDO.DB_FILE_PATH,UploadInfoDO.DB_FILE_PATH);

            fieldMap.put(UploadInfoDO.FILE_SIZE,UploadInfoDO.DB_FILE_SIZE);
            fieldMap.put(UploadInfoDO.DB_FILE_SIZE,UploadInfoDO.DB_FILE_SIZE);

            fieldMap.put(UploadInfoDO.UPLOAD_USER_ID,UploadInfoDO.DB_UPLOAD_USER_ID);
            fieldMap.put(UploadInfoDO.DB_UPLOAD_USER_ID,UploadInfoDO.DB_UPLOAD_USER_ID);

            fieldMap.put(UploadInfoDO.FILE_DETAIL,UploadInfoDO.DB_FILE_DETAIL);
            fieldMap.put(UploadInfoDO.DB_FILE_DETAIL,UploadInfoDO.DB_FILE_DETAIL);

            fieldMap.put(UploadInfoDO.IS_DELETED,UploadInfoDO.DB_IS_DELETED);
            fieldMap.put(UploadInfoDO.DB_IS_DELETED,UploadInfoDO.DB_IS_DELETED);

            fieldMap.put(UploadInfoDO.GMT_CREATE,UploadInfoDO.DB_GMT_CREATE);
            fieldMap.put(UploadInfoDO.DB_GMT_CREATE,UploadInfoDO.DB_GMT_CREATE);

            fieldMap.put(UploadInfoDO.GMT_MODIFIED,UploadInfoDO.DB_GMT_MODIFIED);
            fieldMap.put(UploadInfoDO.DB_GMT_MODIFIED,UploadInfoDO.DB_GMT_MODIFIED);

            fieldMap.put(UploadInfoDO.USER_ID_CREATE,UploadInfoDO.DB_USER_ID_CREATE);
            fieldMap.put(UploadInfoDO.DB_USER_ID_CREATE,UploadInfoDO.DB_USER_ID_CREATE);

            fieldMap.put(UploadInfoDO.USER_ID_MODIFIED,UploadInfoDO.DB_USER_ID_MODIFIED);
            fieldMap.put(UploadInfoDO.DB_USER_ID_MODIFIED,UploadInfoDO.DB_USER_ID_MODIFIED);



            super.setFieldNameMap(fieldMap);
        }



        public List<UploadInfoDO> listByOriginalFileName(String originalFileName, String... fieldNames){
            return this.uploadInfoMapper.listByOriginalFileName(originalFileName,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByOriginalFileName(String originalFileName, String... fieldNames){
            return this.uploadInfoMapper.mapByOriginalFileName(originalFileName,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByOriginalFileName(String originalFileName){
            return this.uploadInfoMapper.countByOriginalFileName(originalFileName);
        }

        public Integer updateNotNullFieldsByOriginalFileName(UploadInfoDO updateDO, String originalFileName){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByOriginalFileName(updateDO,originalFileName);
        }

        public Integer updateAllFieldsByOriginalFileName(UploadInfoDO updateDO,  String originalFileName){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByOriginalFileName(updateDO,originalFileName);
        }

        public Integer deleteByOriginalFileName( String originalFileName){
            return this.uploadInfoMapper.deleteByOriginalFileName(originalFileName);
        }



        public List<UploadInfoDO> listByInOriginalFileName(Collection<String> originalFileNameList, String... fieldNames){
            return this.uploadInfoMapper.listByInOriginalFileName(originalFileNameList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInOriginalFileName(Collection<String> originalFileNameList, String... fieldNames){
            return this.uploadInfoMapper.mapByInOriginalFileName(originalFileNameList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInOriginalFileName(Collection<String> originalFileNameList){
            return this.uploadInfoMapper.countByInOriginalFileName(originalFileNameList);
        }

        public Integer updateNotNullFieldsByInOriginalFileName(UploadInfoDO updateDO, Collection<String> originalFileNameList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInOriginalFileName(updateDO,originalFileNameList);
        }

        public Integer updateAllFieldsByInOriginalFileName(UploadInfoDO updateDO,  Collection<String> originalFileNameList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInOriginalFileName(updateDO,originalFileNameList);
        }

        public Integer deleteByInOriginalFileName( Collection<String> originalFileNameList){
            return this.uploadInfoMapper.deleteByInOriginalFileName(originalFileNameList);
        }


        public List<UploadInfoDO> listByFileName(String fileName, String... fieldNames){
            return this.uploadInfoMapper.listByFileName(fileName,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByFileName(String fileName, String... fieldNames){
            return this.uploadInfoMapper.mapByFileName(fileName,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByFileName(String fileName){
            return this.uploadInfoMapper.countByFileName(fileName);
        }

        public Integer updateNotNullFieldsByFileName(UploadInfoDO updateDO, String fileName){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByFileName(updateDO,fileName);
        }

        public Integer updateAllFieldsByFileName(UploadInfoDO updateDO,  String fileName){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByFileName(updateDO,fileName);
        }

        public Integer deleteByFileName( String fileName){
            return this.uploadInfoMapper.deleteByFileName(fileName);
        }



        public List<UploadInfoDO> listByInFileName(Collection<String> fileNameList, String... fieldNames){
            return this.uploadInfoMapper.listByInFileName(fileNameList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInFileName(Collection<String> fileNameList, String... fieldNames){
            return this.uploadInfoMapper.mapByInFileName(fileNameList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInFileName(Collection<String> fileNameList){
            return this.uploadInfoMapper.countByInFileName(fileNameList);
        }

        public Integer updateNotNullFieldsByInFileName(UploadInfoDO updateDO, Collection<String> fileNameList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInFileName(updateDO,fileNameList);
        }

        public Integer updateAllFieldsByInFileName(UploadInfoDO updateDO,  Collection<String> fileNameList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInFileName(updateDO,fileNameList);
        }

        public Integer deleteByInFileName( Collection<String> fileNameList){
            return this.uploadInfoMapper.deleteByInFileName(fileNameList);
        }


        public List<UploadInfoDO> listByFileSuffix(String fileSuffix, String... fieldNames){
            return this.uploadInfoMapper.listByFileSuffix(fileSuffix,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByFileSuffix(String fileSuffix, String... fieldNames){
            return this.uploadInfoMapper.mapByFileSuffix(fileSuffix,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByFileSuffix(String fileSuffix){
            return this.uploadInfoMapper.countByFileSuffix(fileSuffix);
        }

        public Integer updateNotNullFieldsByFileSuffix(UploadInfoDO updateDO, String fileSuffix){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByFileSuffix(updateDO,fileSuffix);
        }

        public Integer updateAllFieldsByFileSuffix(UploadInfoDO updateDO,  String fileSuffix){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByFileSuffix(updateDO,fileSuffix);
        }

        public Integer deleteByFileSuffix( String fileSuffix){
            return this.uploadInfoMapper.deleteByFileSuffix(fileSuffix);
        }



        public List<UploadInfoDO> listByInFileSuffix(Collection<String> fileSuffixList, String... fieldNames){
            return this.uploadInfoMapper.listByInFileSuffix(fileSuffixList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInFileSuffix(Collection<String> fileSuffixList, String... fieldNames){
            return this.uploadInfoMapper.mapByInFileSuffix(fileSuffixList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInFileSuffix(Collection<String> fileSuffixList){
            return this.uploadInfoMapper.countByInFileSuffix(fileSuffixList);
        }

        public Integer updateNotNullFieldsByInFileSuffix(UploadInfoDO updateDO, Collection<String> fileSuffixList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInFileSuffix(updateDO,fileSuffixList);
        }

        public Integer updateAllFieldsByInFileSuffix(UploadInfoDO updateDO,  Collection<String> fileSuffixList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInFileSuffix(updateDO,fileSuffixList);
        }

        public Integer deleteByInFileSuffix( Collection<String> fileSuffixList){
            return this.uploadInfoMapper.deleteByInFileSuffix(fileSuffixList);
        }


        public List<UploadInfoDO> listByFilePath(String filePath, String... fieldNames){
            return this.uploadInfoMapper.listByFilePath(filePath,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByFilePath(String filePath, String... fieldNames){
            return this.uploadInfoMapper.mapByFilePath(filePath,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByFilePath(String filePath){
            return this.uploadInfoMapper.countByFilePath(filePath);
        }

        public Integer updateNotNullFieldsByFilePath(UploadInfoDO updateDO, String filePath){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByFilePath(updateDO,filePath);
        }

        public Integer updateAllFieldsByFilePath(UploadInfoDO updateDO,  String filePath){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByFilePath(updateDO,filePath);
        }

        public Integer deleteByFilePath( String filePath){
            return this.uploadInfoMapper.deleteByFilePath(filePath);
        }



        public List<UploadInfoDO> listByInFilePath(Collection<String> filePathList, String... fieldNames){
            return this.uploadInfoMapper.listByInFilePath(filePathList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInFilePath(Collection<String> filePathList, String... fieldNames){
            return this.uploadInfoMapper.mapByInFilePath(filePathList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInFilePath(Collection<String> filePathList){
            return this.uploadInfoMapper.countByInFilePath(filePathList);
        }

        public Integer updateNotNullFieldsByInFilePath(UploadInfoDO updateDO, Collection<String> filePathList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInFilePath(updateDO,filePathList);
        }

        public Integer updateAllFieldsByInFilePath(UploadInfoDO updateDO,  Collection<String> filePathList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInFilePath(updateDO,filePathList);
        }

        public Integer deleteByInFilePath( Collection<String> filePathList){
            return this.uploadInfoMapper.deleteByInFilePath(filePathList);
        }


        public List<UploadInfoDO> listByFileSize(Long fileSize, String... fieldNames){
            return this.uploadInfoMapper.listByFileSize(fileSize,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByFileSize(Long fileSize, String... fieldNames){
            return this.uploadInfoMapper.mapByFileSize(fileSize,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByFileSize(Long fileSize){
            return this.uploadInfoMapper.countByFileSize(fileSize);
        }

        public Integer updateNotNullFieldsByFileSize(UploadInfoDO updateDO, Long fileSize){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByFileSize(updateDO,fileSize);
        }

        public Integer updateAllFieldsByFileSize(UploadInfoDO updateDO,  Long fileSize){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByFileSize(updateDO,fileSize);
        }

        public Integer deleteByFileSize( Long fileSize){
            return this.uploadInfoMapper.deleteByFileSize(fileSize);
        }



        public List<UploadInfoDO> listByInFileSize(Collection<Long> fileSizeList, String... fieldNames){
            return this.uploadInfoMapper.listByInFileSize(fileSizeList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInFileSize(Collection<Long> fileSizeList, String... fieldNames){
            return this.uploadInfoMapper.mapByInFileSize(fileSizeList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInFileSize(Collection<Long> fileSizeList){
            return this.uploadInfoMapper.countByInFileSize(fileSizeList);
        }

        public Integer updateNotNullFieldsByInFileSize(UploadInfoDO updateDO, Collection<Long> fileSizeList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInFileSize(updateDO,fileSizeList);
        }

        public Integer updateAllFieldsByInFileSize(UploadInfoDO updateDO,  Collection<Long> fileSizeList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInFileSize(updateDO,fileSizeList);
        }

        public Integer deleteByInFileSize( Collection<Long> fileSizeList){
            return this.uploadInfoMapper.deleteByInFileSize(fileSizeList);
        }


        public List<UploadInfoDO> listByUploadUserId(Long uploadUserId, String... fieldNames){
            return this.uploadInfoMapper.listByUploadUserId(uploadUserId,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByUploadUserId(Long uploadUserId, String... fieldNames){
            return this.uploadInfoMapper.mapByUploadUserId(uploadUserId,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByUploadUserId(Long uploadUserId){
            return this.uploadInfoMapper.countByUploadUserId(uploadUserId);
        }

        public Integer updateNotNullFieldsByUploadUserId(UploadInfoDO updateDO, Long uploadUserId){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByUploadUserId(updateDO,uploadUserId);
        }

        public Integer updateAllFieldsByUploadUserId(UploadInfoDO updateDO,  Long uploadUserId){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByUploadUserId(updateDO,uploadUserId);
        }

        public Integer deleteByUploadUserId( Long uploadUserId){
            return this.uploadInfoMapper.deleteByUploadUserId(uploadUserId);
        }



        public List<UploadInfoDO> listByInUploadUserId(Collection<Long> uploadUserIdList, String... fieldNames){
            return this.uploadInfoMapper.listByInUploadUserId(uploadUserIdList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInUploadUserId(Collection<Long> uploadUserIdList, String... fieldNames){
            return this.uploadInfoMapper.mapByInUploadUserId(uploadUserIdList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInUploadUserId(Collection<Long> uploadUserIdList){
            return this.uploadInfoMapper.countByInUploadUserId(uploadUserIdList);
        }

        public Integer updateNotNullFieldsByInUploadUserId(UploadInfoDO updateDO, Collection<Long> uploadUserIdList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInUploadUserId(updateDO,uploadUserIdList);
        }

        public Integer updateAllFieldsByInUploadUserId(UploadInfoDO updateDO,  Collection<Long> uploadUserIdList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInUploadUserId(updateDO,uploadUserIdList);
        }

        public Integer deleteByInUploadUserId( Collection<Long> uploadUserIdList){
            return this.uploadInfoMapper.deleteByInUploadUserId(uploadUserIdList);
        }


        public List<UploadInfoDO> listByFileDetail(String fileDetail, String... fieldNames){
            return this.uploadInfoMapper.listByFileDetail(fileDetail,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByFileDetail(String fileDetail, String... fieldNames){
            return this.uploadInfoMapper.mapByFileDetail(fileDetail,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByFileDetail(String fileDetail){
            return this.uploadInfoMapper.countByFileDetail(fileDetail);
        }

        public Integer updateNotNullFieldsByFileDetail(UploadInfoDO updateDO, String fileDetail){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByFileDetail(updateDO,fileDetail);
        }

        public Integer updateAllFieldsByFileDetail(UploadInfoDO updateDO,  String fileDetail){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByFileDetail(updateDO,fileDetail);
        }

        public Integer deleteByFileDetail( String fileDetail){
            return this.uploadInfoMapper.deleteByFileDetail(fileDetail);
        }



        public List<UploadInfoDO> listByInFileDetail(Collection<String> fileDetailList, String... fieldNames){
            return this.uploadInfoMapper.listByInFileDetail(fileDetailList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInFileDetail(Collection<String> fileDetailList, String... fieldNames){
            return this.uploadInfoMapper.mapByInFileDetail(fileDetailList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInFileDetail(Collection<String> fileDetailList){
            return this.uploadInfoMapper.countByInFileDetail(fileDetailList);
        }

        public Integer updateNotNullFieldsByInFileDetail(UploadInfoDO updateDO, Collection<String> fileDetailList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInFileDetail(updateDO,fileDetailList);
        }

        public Integer updateAllFieldsByInFileDetail(UploadInfoDO updateDO,  Collection<String> fileDetailList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInFileDetail(updateDO,fileDetailList);
        }

        public Integer deleteByInFileDetail( Collection<String> fileDetailList){
            return this.uploadInfoMapper.deleteByInFileDetail(fileDetailList);
        }


        public List<UploadInfoDO> listByUserIdCreate(Long userIdCreate, String... fieldNames){
            return this.uploadInfoMapper.listByUserIdCreate(userIdCreate,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByUserIdCreate(Long userIdCreate, String... fieldNames){
            return this.uploadInfoMapper.mapByUserIdCreate(userIdCreate,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByUserIdCreate(Long userIdCreate){
            return this.uploadInfoMapper.countByUserIdCreate(userIdCreate);
        }

        public Integer updateNotNullFieldsByUserIdCreate(UploadInfoDO updateDO, Long userIdCreate){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByUserIdCreate(updateDO,userIdCreate);
        }

        public Integer updateAllFieldsByUserIdCreate(UploadInfoDO updateDO,  Long userIdCreate){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByUserIdCreate(updateDO,userIdCreate);
        }

        public Integer deleteByUserIdCreate( Long userIdCreate){
            return this.uploadInfoMapper.deleteByUserIdCreate(userIdCreate);
        }



        public List<UploadInfoDO> listByInUserIdCreate(Collection<Long> userIdCreateList, String... fieldNames){
            return this.uploadInfoMapper.listByInUserIdCreate(userIdCreateList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInUserIdCreate(Collection<Long> userIdCreateList, String... fieldNames){
            return this.uploadInfoMapper.mapByInUserIdCreate(userIdCreateList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInUserIdCreate(Collection<Long> userIdCreateList){
            return this.uploadInfoMapper.countByInUserIdCreate(userIdCreateList);
        }

        public Integer updateNotNullFieldsByInUserIdCreate(UploadInfoDO updateDO, Collection<Long> userIdCreateList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInUserIdCreate(updateDO,userIdCreateList);
        }

        public Integer updateAllFieldsByInUserIdCreate(UploadInfoDO updateDO,  Collection<Long> userIdCreateList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInUserIdCreate(updateDO,userIdCreateList);
        }

        public Integer deleteByInUserIdCreate( Collection<Long> userIdCreateList){
            return this.uploadInfoMapper.deleteByInUserIdCreate(userIdCreateList);
        }


        public List<UploadInfoDO> listByUserIdModified(Long userIdModified, String... fieldNames){
            return this.uploadInfoMapper.listByUserIdModified(userIdModified,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByUserIdModified(Long userIdModified, String... fieldNames){
            return this.uploadInfoMapper.mapByUserIdModified(userIdModified,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByUserIdModified(Long userIdModified){
            return this.uploadInfoMapper.countByUserIdModified(userIdModified);
        }

        public Integer updateNotNullFieldsByUserIdModified(UploadInfoDO updateDO, Long userIdModified){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByUserIdModified(updateDO,userIdModified);
        }

        public Integer updateAllFieldsByUserIdModified(UploadInfoDO updateDO,  Long userIdModified){
            if (super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByUserIdModified(updateDO,userIdModified);
        }

        public Integer deleteByUserIdModified( Long userIdModified){
            return this.uploadInfoMapper.deleteByUserIdModified(userIdModified);
        }



        public List<UploadInfoDO> listByInUserIdModified(Collection<Long> userIdModifiedList, String... fieldNames){
            return this.uploadInfoMapper.listByInUserIdModified(userIdModifiedList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Map<Long,UploadInfoDO> mapByInUserIdModified(Collection<Long> userIdModifiedList, String... fieldNames){
            return this.uploadInfoMapper.mapByInUserIdModified(userIdModifiedList,super.javaFieldNames2DataBaseNames(fieldNames));
        }

        public Integer countByInUserIdModified(Collection<Long> userIdModifiedList){
            return this.uploadInfoMapper.countByInUserIdModified(userIdModifiedList);
        }

        public Integer updateNotNullFieldsByInUserIdModified(UploadInfoDO updateDO, Collection<Long> userIdModifiedList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateNotNullFieldsByInUserIdModified(updateDO,userIdModifiedList);
        }

        public Integer updateAllFieldsByInUserIdModified(UploadInfoDO updateDO,  Collection<Long> userIdModifiedList){
            if(super.doChecker != null){
                super.doChecker.checkWhenModify(updateDO);
            }
            return this.uploadInfoMapper.updateAllFieldsByInUserIdModified(updateDO,userIdModifiedList);
        }

        public Integer deleteByInUserIdModified( Collection<Long> userIdModifiedList){
            return this.uploadInfoMapper.deleteByInUserIdModified(userIdModifiedList);
        }


}

